#include "usart_485.h"
#include "los_interrupt.h"
#include "los_task.h"


volatile usart6_rx_buf_t usart6_rx_buf; // 全局接收缓冲区
volatile usart6_tx_buf_t usart6_tx_buf;

volatile bool usart6_receiving = false; 


void USART6_IRQHandler(void) 
{
    // 检查接收错误标志
    if(usart_flag_get(USART6, USART_ROERR_FLAG) != RESET) {
        usart_flag_clear(USART6, USART_ROERR_FLAG);
        usart6_clear_rx_buffer();
        return;
    }


    /* 发送中断处理 */
    if (usart_flag_get(USART6, USART_TDBE_FLAG) != RESET) {
        if (usart6_tx_buf.count > 0) {
            usart_data_transmit(USART6, usart6_tx_buf.buf[usart6_tx_buf.tail++]);
            usart6_tx_buf.count--;
            if (usart6_tx_buf.tail >= USART6_TX_BUF_SIZE) {
                usart6_tx_buf.tail = 0;
            }
        } else {
            // 发送完成，禁用发送中断
            usart_interrupt_enable(USART6, USART_TDBE_INT, FALSE);
            usart6_switch_to_receive(); 
        }
    }

    /* 接收中断处理 */
    if (usart_flag_get(USART6, USART_RDBF_FLAG) != RESET) {
    // 读取接收到的数据
        uint8_t data = usart_data_receive(USART6);
        // 检查缓冲区是否已满
        if (usart6_rx_buf.count < USART6_RX_BUF_SIZE) {
            usart6_rx_buf.buf[usart6_rx_buf.head++] = data;
            if (usart6_rx_buf.head >= USART6_RX_BUF_SIZE) {
                usart6_rx_buf.head = 0;
            }
            usart6_rx_buf.count++;
        }
    }
}


void usart6_init(uint32_t baudrate)  //4852
{

    usart_enable(USART6, FALSE);
    
    /* 初始化结构体 */
    gpio_init_type gpio_init_struct;
    gpio_default_para_init(&gpio_init_struct);

    crm_periph_clock_enable(CRM_GPIOC_PERIPH_CLOCK, TRUE);
    crm_periph_clock_enable(CRM_USART6_PERIPH_CLOCK, TRUE);

    /* 配置 USART6 TX 引脚（PC6） */
    gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_MODERATE;//设置 GPIO 驱动强度为 中等
    gpio_init_struct.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;//推挽输出（PUSH_PULL）
    gpio_init_struct.gpio_mode = GPIO_MODE_MUX;//复用模式（MUX）
    gpio_init_struct.gpio_pins = GPIO_PINS_6;//选择 PC6 作为 TX 引脚
    gpio_init_struct.gpio_pull = GPIO_PULL_NONE;//无上下拉（PULL_NONE）
    gpio_init(GPIOC, &gpio_init_struct);//应用配置到 GPIOC 的 PC6 引脚

    /* 配置 USART6 RX 引脚（PC7） */
    gpio_init_struct.gpio_mode = GPIO_MODE_INPUT;//设置为输入模式（INPUT）
    gpio_init_struct.gpio_pins = GPIO_PINS_7;//选择 PC7 作为 RX 引脚
    gpio_init_struct.gpio_pull = GPIO_PULL_UP;//上拉
    gpio_init(GPIOC, &gpio_init_struct);//应用配置到 GPIOC 的 PC6 引脚

    /* 配置 USART6 通信参数 */
    // printf("[USART6] Setting communication parameters...\n");
    // printf("[USART6] Baudrate: %lu, Data: 9 bits, Parity: Even, Stop: 1 bit\n", baudrate);
    usart_parity_selection_config(USART6, USART_PARITY_NONE);// 配置USART1的奇偶校验为偶校验
    // printf("[USART6] Initializing USART6\n");
    usart_init(USART6, baudrate, USART_DATA_8BITS, USART_STOP_1_BIT);// 初始化USART1
//    usart_init(USART6, baudrate, USART_DATA_8BITS, USART_STOP_1_BIT);
//    usart_parity_selection_config(USART6, USART_PARITY_NONE);
    usart_hardware_flow_control_set(USART6, USART_HARDWARE_FLOW_NONE);

    /* 使能 USART6 发送器和接收器 */
    usart_transmitter_enable(USART6, TRUE);
    usart_receiver_enable(USART6, TRUE);

    LOS_HwiCreate(USART6_IRQn, 0, 0, USART6_IRQHandler, 0);

    /*使能接收中断*/
    nvic_irq_enable(USART6_IRQn, 1, 0); 

    /* 初始化接收缓冲区 */
    usart6_rx_buf.head = 0;
    usart6_rx_buf.tail = 0;
    usart6_rx_buf.count = 0;


    usart6_tx_buf.head = 0;
    usart6_tx_buf.tail = 0;
    usart6_tx_buf.count = 0;

    /*使能串口6*/
    printf("[USART6] Enabling USART6...\r\n");
    usart_enable(USART6, TRUE);

    /* 默认设置为接收模式 */
    usart6_switch_to_receive();
    printf("[USART6] USART6 initialization completed successfully\r\n");
}

/* 中断发送 */
void usart6_send_data_it(uint8_t *data, uint16_t len) 
{
    // 切换到发送模式
    usart6_switch_to_send();
    
    /* 将数据存入发送缓冲区 */
    for (uint16_t i = 0; i < len; i++) {
        while (usart6_tx_buf.count >= USART6_TX_BUF_SIZE); // 等待缓冲区空间

        usart6_tx_buf.buf[usart6_tx_buf.head++] = data[i];
        if (usart6_tx_buf.head >= USART6_TX_BUF_SIZE) {
            usart6_tx_buf.head = 0;
        }
        usart6_tx_buf.count++;
    }

    /* 触发发送中断 */
    usart_interrupt_enable(USART6, USART_TDBE_INT, TRUE);
}

/* 切换到接收模式 */
void usart6_switch_to_receive(void) {
    // 禁用发送中断
    usart_interrupt_enable(USART6, USART_TDBE_INT, FALSE);
    
    // 使能接收中断
    usart_interrupt_enable(USART6, USART_RDBF_INT, TRUE);
    
    usart6_receiving = true;
}

/* 切换到发送模式 */
void usart6_switch_to_send(void) {
    // 禁用接收中断
    usart_interrupt_enable(USART6, USART_RDBF_INT, FALSE);
    
    // 使能发送中断
    usart_interrupt_enable(USART6, USART_TDBE_INT, TRUE);
    
    usart6_receiving = false;
}


/* 获取接收到的数据长度 */
uint16_t usart6_get_rx_data_len(void) 
{
    return usart6_rx_buf.count;
}

/* 读取接收缓冲区数据 */
uint16_t usart6_read_rx_data(uint8_t *buf, uint16_t len)
{
    uint16_t i = 0;
    while (usart6_rx_buf.count > 0 && i < len) {
        buf[i++] = usart6_rx_buf.buf[usart6_rx_buf.tail++];
        if (usart6_rx_buf.tail >= USART6_RX_BUF_SIZE) {
            usart6_rx_buf.tail = 0;
        }
        usart6_rx_buf.count--;
    }
    return i;
}

/* 清空接收缓冲区 */
void usart6_clear_rx_buffer(void)
{
    usart6_rx_buf.head = 0;
    usart6_rx_buf.tail = 0;
    usart6_rx_buf.count = 0;
}

/*测试函数，将接收到的数据发出去*/
void usart6_echo_handler(void)
{
    static uint8_t rx_buffer[USART6_RX_BUF_SIZE];
    uint16_t len = usart6_get_rx_data_len();
    if(len > 0)
    {
        // 读取接收到的数据
        uint16_t read_len = usart6_read_rx_data(rx_buffer, len);
        
        #if ECHO_ENABLED
        // 将接收到的数据发送回去
        usart6_send_data_it(rx_buffer, read_len);
        #endif
        
    }
}

u8 get_usart6_handler(u8* rx_data)
{
    uint16_t len = usart6_get_rx_data_len();
    
    if(len > 0)
    {
        // 读取接收到的数据
         usart6_read_rx_data(rx_data, len);
    }
    return len;
}